/**
 * 课程提醒管理工具
 * 基于uni-app的本地推送消息实现课程提醒功能
 */

class CourseReminder {
	constructor() {
		this.reminderPrefix = 'course_reminder_'
		this.defaultReminderMinutes = 15 // 默认提前15分钟提醒
		this.checkTimer = null // 实时检查定时器
		this.courses = [] // 存储课程列表
	}
	
	/**
	 * 初始化提醒服务
	 */
	async init() {
		try {
			// 检查推送权限
			await this.checkPushPermission()
			console.log('课程提醒服务初始化成功')
		} catch (error) {
			console.error('课程提醒服务初始化失败:', error)
			throw error
		}
	}
	
	/**
	 * 检查推送权限
	 */
	async checkPushPermission() {
		return new Promise((resolve, reject) => {
			// #ifdef APP-PLUS
			const main = plus.android.runtimeMainActivity()
			const pkgName = main.getPackageName()
			const uid = main.getApplicationInfo().uid
			const NotificationManagerCompat = plus.android.importClass("androidx.core.app.NotificationManagerCompat")
			
			if (NotificationManagerCompat.from(main).areNotificationsEnabled()) {
				resolve(true)
			} else {
				// 引导用户开启通知权限
				uni.showModal({
					title: '需要通知权限',
					content: '为了及时提醒您上课，请开启通知权限',
					confirmText: '去设置',
					success: (res) => {
						if (res.confirm) {
							const Intent = plus.android.importClass('android.content.Intent')
							const Settings = plus.android.importClass('android.provider.Settings')
							const intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
							const Uri = plus.android.importClass('android.net.Uri')
							intent.setData(Uri.parse("package:" + pkgName))
							main.startActivity(intent)
						}
						resolve(false)
					}
				})
			}
			// #endif
			
			// #ifndef APP-PLUS
			// 非APP平台，直接返回true
			resolve(true)
			// #endif
		})
	}
	
	/**
	 * 为所有课程设置提醒（已弃用，仅保留用于向后兼容）
	 * 现在使用实时检查器替代预设提醒
	 * @param {Array} courses 课程列表
	 * @param {Number} reminderMinutes 提前提醒分钟数，默认15分钟
	 */
	async setRemindersForCourses(courses, reminderMinutes = this.defaultReminderMinutes) {
		console.log('setRemindersForCourses 已弃用，现在使用实时检查器')
		return { success: true, count: courses.length }
	}
	
	/**
	 * 为单门课程设置提醒（已弃用，仅保留用于测试）
	 * 现在使用实时检查器替代预设提醒
	 * @param {Object} course 课程对象
	 * @param {Number} reminderMinutes 提前提醒分钟数
	 */
	async setReminderForCourse(course, reminderMinutes = this.defaultReminderMinutes) {
		if (!course.startTime || !course.title) {
			console.warn('课程信息不完整，跳过设置提醒:', course)
			return
		}
		
		// 仅用于测试目的，创建立即发送的提醒
		if (course.id && course.id.startsWith('test_')) {
			try {
				const now = new Date()
				const courseStartTime = new Date(course.startTime)
				
				// 计算提醒时间（上课前指定分钟数）
				const reminderTime = new Date(courseStartTime.getTime() - reminderMinutes * 60 * 1000)
				
				// 计算实际的提前时间（实时计算）
				const actualReminderMinutes = Math.max(0, Math.round((courseStartTime.getTime() - reminderTime.getTime()) / (1000 * 60)))
				
				// 创建提醒消息
				const message = {
					id: 'test_' + Date.now(),
					title: '上课提醒',
					content: `${course.title} 将在 ${actualReminderMinutes} 分钟后开始`,
					when: reminderTime,
					extra: {
						courseId: course.id,
						courseTitle: course.title,
						courseLocation: course.location || '',
						courseTeacher: course.teacher || '',
						startTime: course.startTime.toISOString(),
						reminderMinutes: actualReminderMinutes
					}
				}
				
				// 设置本地推送消息
				await this.createLocalNotification(message)
				
				console.log(`已设置测试提醒: ${course.title} (${actualReminderMinutes}分钟后开始)`)
			} catch (error) {
				console.error(`设置测试提醒失败:`, error)
			}
		} else {
			console.log(`跳过预设提醒: ${course.title}，现在使用实时检查器`)
		}
	}
	
	/**
	 * 创建本地推送消息
	 * @param {Object} message 消息对象
	 */
	createLocalNotification(message) {
		return new Promise((resolve, reject) => {
			// #ifdef APP-PLUS
			const options = {
				cover: false,
				icon: '/static/logo.png',
				sound: 'system',
				title: message.title,
				content: message.content,
				when: message.when,
				category: 'course_reminder'
			}
			
			// 添加额外数据
			if (message.extra) {
				options.extra = message.extra
			}
			
			uni.createPushMessage({
				...options,
				success: (res) => {
					console.log('本地推送消息创建成功:', res)
					resolve(res)
				},
				fail: (error) => {
					console.error('本地推送消息创建失败:', error)
					reject(error)
				}
			})
			// #endif
			
			// #ifndef APP-PLUS
			// 非APP平台，模拟成功
			console.log('非APP平台，模拟推送消息创建成功:', message.title)
			resolve({ success: true })
			// #endif
		})
	}
	
	/**
	 * 清除所有课程提醒
	 */
	async clearAllReminders() {
		try {
			// 停止实时检查器
			this.stopRealTimeChecker()
			
			// 清空课程列表
			this.courses = []
			
			// 清除已发送提醒的标记
			const storage = uni.getStorageInfoSync()
			storage.keys.forEach(key => {
				if (key.startsWith('sent_')) {
					uni.removeStorageSync(key)
				}
			})
			
			console.log('已清除实时提醒检查器和所有提醒标记')
		} catch (error) {
			console.error('清除课程提醒失败:', error)
		}
	}
	
	/**
	 * 取消单个提醒
	 * @param {String} reminderId 提醒ID
	 */
	cancelReminder(reminderId) {
		return new Promise((resolve) => {
			// #ifdef APP-PLUS
			// 注意：uni-app的createPushMessage创建的本地通知会在触发后自动清除
			// 这里主要是清理我们自己维护的ID列表
			console.log('取消提醒:', reminderId)
			// #endif
			resolve()
		})
	}
	
	/**
	 * 获取提醒设置
	 */
	getReminderSettings() {
		const settings = uni.getStorageSync('course_reminder_settings') || {
			enabled: true,
			reminderMinutes: this.defaultReminderMinutes,
			soundEnabled: true,
			vibrationEnabled: true
		}
		return settings
	}
	
	/**
	 * 保存提醒设置
	 * @param {Object} settings 设置对象
	 */
	saveReminderSettings(settings) {
		uni.setStorageSync('course_reminder_settings', settings)
		console.log('提醒设置已保存:', settings)
	}
	
	/**
	 * 更新课程提醒（当课程发生变化时调用）
	 * @param {Array} courses 新的课程列表
	 */
	async updateReminders(courses) {
		const settings = this.getReminderSettings()
		if (!settings.enabled) {
			console.log('课程提醒已禁用，跳过更新')
			this.stopRealTimeChecker()
			return
		}
		
		try {
			// 启动实时检查器 - 只使用实时检查，不预设提醒
			this.startRealTimeChecker(courses)
			console.log('实时课程提醒检查器已启动')
			return { success: true, count: courses.length }
		} catch (error) {
			console.error('启动实时提醒检查器失败:', error)
			throw error
		}
	}
	
	/**
	 * 获取即将到来的提醒列表
	 * @param {Number} hours 未来几小时内的提醒，默认24小时
	 */
	getUpcomingReminders(hours = 24) {
		// 这个方法可以用来显示即将到来的提醒列表
		// 实际实现需要根据存储的提醒数据来获取
		const now = new Date()
		const future = new Date(now.getTime() + hours * 60 * 60 * 1000)
		
		// 这里应该从存储中获取提醒数据并筛选
		// 暂时返回空数组
		return []
	}
	
	/**
	 * 启动实时提醒检查器
	 * 每分钟检查一次是否有课程需要发送提醒
	 * @param {Array} courses 课程列表
	 */
	startRealTimeChecker(courses) {
		// 存储课程列表
		this.courses = courses
		
		// 清除之前的定时器
		if (this.checkTimer) {
			clearInterval(this.checkTimer)
		}
		
		// 每30秒检查一次，确保准确性
		this.checkTimer = setInterval(() => {
			this.checkAndSendReminders()
		}, 30 * 1000) // 30秒检查一次
		
		console.log(`实时提醒检查器已启动，监控 ${courses.length} 门课程`)
	}
	
	/**
	 * 停止实时提醒检查器
	 */
	stopRealTimeChecker() {
		if (this.checkTimer) {
			clearInterval(this.checkTimer)
			this.checkTimer = null
			console.log('实时提醒检查器已停止')
		}
		// 清空课程列表
		this.courses = []
	}
	
	/**
	 * 检查并发送提醒
	 */
	async checkAndSendReminders() {
		const now = new Date()
		const settings = this.getReminderSettings()
		
		if (!settings.enabled || !this.courses || this.courses.length === 0) {
			return
		}
		
		const reminderMinutes = settings.reminderMinutes
		console.log(`[${now.toLocaleTimeString()}] 检查课程提醒，提前 ${reminderMinutes} 分钟`)
		
		for (const course of this.courses) {
			if (!course.startTime || !course.title) continue
			
			const courseStartTime = new Date(course.startTime)
			const timeDiffMinutes = Math.round((courseStartTime.getTime() - now.getTime()) / (1000 * 60))
			
			// 检查是否正好是提醒时间（误差±1分钟内）
			if (Math.abs(timeDiffMinutes - reminderMinutes) <= 1) {
				// 检查是否已经发送过这个提醒
				const reminderKey = `sent_${course.id}_${courseStartTime.toDateString()}`
				const alreadySent = uni.getStorageSync(reminderKey)
				
				if (!alreadySent) {
					console.log(`发送课程提醒: ${course.title} (${timeDiffMinutes}分钟后开始)`)
					await this.sendImmediateReminder(course, timeDiffMinutes)
					// 标记已发送
					uni.setStorageSync(reminderKey, true)
					
					// 设置过期时间（课程结束后清除标记）
					const courseEndTime = course.endTime ? new Date(course.endTime) : new Date(courseStartTime.getTime() + 2 * 60 * 60 * 1000)
					if (courseEndTime > now) {
						setTimeout(() => {
							uni.removeStorageSync(reminderKey)
						}, courseEndTime.getTime() - now.getTime())
					}
				} else {
					console.log(`课程提醒已发送过: ${course.title}`)
				}
			}
		}
	}
	
	/**
	 * 立即发送提醒
	 * @param {Object} course 课程对象
	 * @param {Number} minutesUntilStart 距离开始的分钟数
	 */
	async sendImmediateReminder(course, minutesUntilStart) {
		try {
			const message = {
				id: 'immediate_' + course.id + '_' + Date.now(),
				title: '上课提醒',
				content: `${course.title} 将在 ${minutesUntilStart} 分钟后开始`,
				when: new Date(), // 立即发送
				extra: {
					courseId: course.id,
					courseTitle: course.title,
					courseLocation: course.location || '',
					courseTeacher: course.teacher || '',
					startTime: course.startTime.toISOString(),
					reminderMinutes: minutesUntilStart
				}
			}
			
			await this.createLocalNotification(message)
			console.log(`已发送实时提醒: ${course.title} (${minutesUntilStart}分钟后开始)`)
		} catch (error) {
			console.error('发送实时提醒失败:', error)
		}
	}
}

// 创建单例实例
const courseReminder = new CourseReminder()

export default courseReminder 